import com.xjcs.saplingplan.http.BaseResponse
import com.xjcs.saplingplan.http.BusinessException
import com.xjcs.saplingplan.http.ConnectionException
import com.xjcs.saplingplan.http.HttpException
import com.xjcs.saplingplan.http.NetworkException
import com.xjcs.saplingplan.http.ParseErrorException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.IOException
import retrofit2.HttpException as RetrofitHttpException

object NetworkClient {
    /**
     * 通用网络请求方法（协程挂起函数）
     * @param call 实际请求的suspend函数（如apiService.login()）
     * @param T 响应数据的泛型（BaseResponse中的data类型）
     * @return Result<T>（统一结果封装）
     */
    suspend inline fun <reified T> request(
        crossinline call: suspend () -> retrofit2.Response<BaseResponse<T>>
    ): Result<T?> {
        return withContext(Dispatchers.IO) {
            try {
                val response = call()
                if (response.isSuccessful) { // HTTP状态码200-299
                    val baseResponse = response.body()
                    if (baseResponse?.isSuccess() == true) { // 业务状态码成功（如code=200）
                        Result.Success(baseResponse.data)
                    } else {
                        // 业务状态码失败（如code=401未登录）
                        Result.Error(
                            exception = BusinessException(
                                code = baseResponse?.code ?: -1,
                                message = baseResponse?.msg ?: "请求失败"
                            )
                        )
                    }
                } else {
                    // HTTP状态码异常（如404、500）
                    Result.Error(
                        exception = HttpException(
                            code = response.code(),
                            message = response.message()
                        )
                    )
                }
            } catch (e: IOException) {
                // 网络连接异常（如超时、无网络）
                Result.Error(exception = ConnectionException(e.message ?: "网络连接失败"))
            } catch (e: RetrofitHttpException) {
                // Retrofit转换异常（如JSON解析失败）
                Result.Error(exception = ParseErrorException(e.message ?: "数据解析失败"))
            } catch (e: Exception) {
                // 其他未知异常
                Result.Error(exception = NetworkException(e.message ?: "网络请求失败"))
            }
        }
    }
}

/** 统一结果封装（成功/错误） */
sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: NetworkException) : Result<Nothing>()
}